//package com.ct.config;
//
//import lombok.extern.slf4j.Slf4j;
//
//import java.util.concurrent.*;
//import java.util.concurrent.atomic.AtomicInteger;
//
///**
// * 线程池配置类
// */
//@Slf4j
//public class ThreadPoolConfig2 {
//
//    /**
//     * CPU核数
//     **/
//    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//    /**
//     * 线程空闲保活时限，单位秒
//     */
//    private static final int KEEP_ALIVE_SECONDS = 30;
//    /**
//     * 有界队列size
//     */
//    private static final int QUEUE_SIZE = 10000;
//
//
//
//
//    /**
//     * 获取执行CPU密集型任务的线程池
//     * @return ThreadPoolExecutor
//     */
//    public static ThreadPoolExecutor getCpuIntenseTargetThreadPool(){
//        return CpuIntenseTargetThreadPoolLazyHolder.EXECUTOR;
//    }
//    /**
//     * 懒汉式单例创建线程池：用于CPU密集型任务
//     */
//    private static final int CORE_POOL_SIZE = CPU_COUNT;            //CPU密集型-核心线程数
//    private static final int MAXIMUM_POOL_SIZE = CORE_POOL_SIZE;    //CPU密集型-最大线程数
//    private static class CpuIntenseTargetThreadPoolLazyHolder{
//        //线程池： 用于CPU密集型任务
//        private static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(
//                CORE_POOL_SIZE,
//                MAXIMUM_POOL_SIZE,
//                KEEP_ALIVE_SECONDS,
//                TimeUnit.SECONDS,
//                new LinkedBlockingQueue<>(QUEUE_SIZE),
//                new CustomThreadFactory("cpu"));
//
//        static {
//            EXECUTOR.allowCoreThreadTimeOut(true);
//            //JVM关闭时的钩子函数
//            Runtime.getRuntime().addShutdownHook(
//                    new ShutdownHookThread("CPU密集型任务线程池", new Callable<Void>() {
//                        @Override
//                        public Void call() throws Exception {
//                            //优雅关闭线程池
//                            shutdownThreadPoolGracefully(EXECUTOR);
//                            return null;
//                        }
//                    }));
//        }
//    }
//
//
//
//    /**
//     * 获取执行IO密集型任务的线程池
//     * @return ThreadPoolExecutor
//     */
//    public static ThreadPoolExecutor getIoIntenseTargetThreadPool(){
//        return IoIntenseTargetThreadPoolLazyHolder.EXECUTOR;
//    }
//    /**
//     * 懒汉式单例创建线程池：用于IO密集型任务
//     */
//    private static final int IO_CORE_POOL_SIZE = CPU_COUNT * 2;                     //IO密集型线程池-核心线程数
//    private static final int IO_MAXIMUM_POOL_SIZE = Math.max(2, IO_CORE_POOL_SIZE); //IO密集型线程池-最大线程数
//    private static class IoIntenseTargetThreadPoolLazyHolder {
//        //线程池： 用于IO密集型任务
//        private static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(
//                IO_CORE_POOL_SIZE,
//                IO_MAXIMUM_POOL_SIZE,
//                KEEP_ALIVE_SECONDS,
//                TimeUnit.SECONDS,
//                new LinkedBlockingQueue<>(QUEUE_SIZE),
//                new CustomThreadFactory("io"));
//
//        static {
//            EXECUTOR.allowCoreThreadTimeOut(true);
//            //JVM关闭时的钩子函数
//            Runtime.getRuntime().addShutdownHook(
//                    new ShutdownHookThread("IO密集型任务线程池", new Callable<Void>() {
//                        @Override
//                        public Void call() throws Exception {
//                            //优雅关闭线程池
//                            shutdownThreadPoolGracefully(EXECUTOR);
//                            return null;
//                        }
//                    }));
//        }
//    }
//
//
//    /**
//     * 获取执行混合型任务的线程池
//     * @return ThreadPoolExecutor
//     */
//    public static ThreadPoolExecutor getMixedTargetThreadPool(){
//        return MixedTargetThreadPoolLazyHolder.EXECUTOR;
//    }
//    /**
//     * 创建混合线程池
//     */
//    private static final int MIXED_CORE_POOL_SIZE = 128;                     //混合线程池-核心线程数
//    private static final int MIXED_MAXIMUM_POOL_SIZE = MIXED_CORE_POOL_SIZE; //混合线程池-最大线程数
//    public static final String MIXED_THREAD_AMOUNT = "mixed.thread.amount";
//    private static class MixedTargetThreadPoolLazyHolder {
//        /*首先从环境变量 mixed.thread.amount 中获取预先配置的线程数。
//        如果没有对 mixed.thread.amount 做配置，则使用常量 MIXED_MAX 作为最大线程数*/
//        private static final int MAX = (System.getProperty(MIXED_THREAD_AMOUNT) != null ) ?
//                Integer.parseInt(System.getProperty(MIXED_THREAD_AMOUNT)) : MIXED_MAXIMUM_POOL_SIZE;
//        //线程池： 用于混合型任务
//        private static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(
//                MIXED_CORE_POOL_SIZE,
//                MAX,
//                KEEP_ALIVE_SECONDS,
//                TimeUnit.SECONDS,
//                new LinkedBlockingQueue(QUEUE_SIZE),
//                new CustomThreadFactory("mixed"));
//
//        static {
//            EXECUTOR.allowCoreThreadTimeOut(true);
//            //JVM关闭时的钩子函数
//            Runtime.getRuntime().addShutdownHook(new ShutdownHookThread("混合型任务线程池", new Callable<Void>() {
//                @Override
//                public Void call() throws Exception {
//                    //优雅关闭线程池
//                    shutdownThreadPoolGracefully(EXECUTOR);
//                    return null;
//                }
//            }));
//        }
//    }
//
//
//    /**
//     * 获取可调度线程池（包含提交延迟、定时、周期性、顺序性执行的任务）
//     */
//    public static ScheduledThreadPoolExecutor getSeqOrScheduledExecutorService(){
//        return SeqOrScheduledTargetThreadPoolLazyHolder.EXECUTOR;
//    }
//    /**
//     * 懒汉式单例创建线程池：用于定时任务、顺序排队执行任务
//     */
//    static class SeqOrScheduledTargetThreadPoolLazyHolder {
//        //线程池：用于定时任务、顺序排队执行任务
//        static final ScheduledThreadPoolExecutor EXECUTOR = new ScheduledThreadPoolExecutor(
//                1,
//                new CustomThreadFactory("seq"));
//
//        static {
//            //JVM关闭时的钩子函数
//            Runtime.getRuntime().addShutdownHook(
//                    new ShutdownHookThread("定时和顺序任务线程池", new Callable<Void>() {
//                        @Override
//                        public Void call() throws Exception {
//                            //优雅关闭线程池
//                            shutdownThreadPoolGracefully(EXECUTOR);
//                            return null;
//                        }
//                    }));
//        }
//    }
//
//
//
//
//
//
//    /**
//     * 定制的线程工厂
//     */
//    private static class CustomThreadFactory implements ThreadFactory {
//        //线程池数量
//        private static final AtomicInteger poolNumber = new AtomicInteger(1);
//        private final ThreadGroup group;
//
//        //线程数量
//        private final AtomicInteger threadNumber = new AtomicInteger(1);
//        private final String threadTag;
//
//        private CustomThreadFactory(String threadTag) {
//            @SuppressWarnings("removal")
//            SecurityManager securityManager = System.getSecurityManager();
//            this.group = (securityManager != null) ? securityManager.getThreadGroup() :
//                    Thread.currentThread().getThreadGroup();
//            this.threadTag = "ct-pool-" + poolNumber.getAndIncrement() + "-" + threadTag + "-";
//        }
//
//        @Override
//        public Thread newThread(Runnable target) {
//            Thread t = new Thread(group, target,
//                    threadTag + threadNumber.getAndIncrement(),
//                    0);
//            if (t.isDaemon()) {
//                t.setDaemon(false);
//            }
//            if (t.getPriority() != Thread.NORM_PRIORITY) {
//                t.setPriority(Thread.NORM_PRIORITY);
//            }
//            return t;
//        }
//    }
//
//
//    /**
//     * 优雅的关闭线程池
//     */
//    public static void shutdownThreadPoolGracefully(ExecutorService threadPool) {
//        //若已经关闭则返回
//        if (threadPool == null || threadPool.isTerminated()) {
//            return;
//        }
//
//        try {
//            //关闭线程池，拒绝接受新任务
//            threadPool.shutdownNow();
//        } catch (Exception e) {
//            return;
//        }
//
//        try {
//            // 等待60秒，等待线程池中的任务完成执行
//            if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
//                // 调用shutdownNow()方法取消正在执行的任务
//                threadPool.shutdownNow();
//                // 再次等待60秒，如果还未结束，可以再次尝试，或者直接放弃
//                if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
//                    log.error("线程池任务未正常执行结束");
//                }
//            }
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//            // 捕获异常，重新调用shutdownNow()方法
//            threadPool.shutdownNow();
//        }
//
//        try {
//            // 等待60秒，等待线程池中的任务完成执行
//            if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
//                // 调用shutdownNow()方法取消正在执行的任务
//                threadPool.shutdownNow();
//                // 再次等待60秒，如果还未结束，可以再次尝试，或者直接放弃
//                if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
//                    log.error("线程池任务未正常执行结束");
//                }
//            }
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//            // 捕获异常，重新调用shutdownNow()方法
//            threadPool.shutdownNow();
//        }
//
//        //仍然没有关闭，循环关闭1000次，每次等待10毫秒
//        if (!threadPool.isTerminated()) {
//            try {
//                for (int i = 0; i < 1000; i++) {
//                    if (threadPool.awaitTermination(10, TimeUnit.MILLISECONDS)) {
//                        break;
//                    }
//                    threadPool.shutdownNow();
//                }
//            } catch (InterruptedException e) {
//                log.error(e.getMessage());
//            } catch (Throwable e) {
//                log.error(e.getMessage());
//            }
//        }
//    }
//
//}